﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using System.IO;
namespace Framework.Common
{
    public static class EncryptHelper
    {
        /// <summary>
        /// MD5函数
        /// </summary>
        /// <param name="str">原始字符串</param>
        /// <returns>MD5结果</returns>
        public static string MD5(string str)
        {
            byte[] b = Encoding.UTF8.GetBytes(str);
            b = new MD5CryptoServiceProvider().ComputeHash(b);
            string ret = "";
            for (int i = 0; i < b.Length; i++)
                ret += b[i].ToString("x").PadLeft(2, '0');

            return ret;
        }

        /// <summary>
        /// SHA256函数
        /// </summary>
        /// /// <param name="str">原始字符串</param>
        /// <returns>SHA256结果</returns>
        public static string SHA256(string str)
        {
            byte[] SHA256Data = Encoding.UTF8.GetBytes(str);
            SHA256Managed Sha256 = new SHA256Managed();
            byte[] Result = Sha256.ComputeHash(SHA256Data);
            return Convert.ToBase64String(Result);  //返回长度为44字节的字符串
        }

        static AES Aes = new AES();
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string Encrypt(string input)
        {
            return Aes.Encrypt(input);
        }

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string Decrypt(string input)
        {
            return Aes.Decrypt(input);
        }


        #region AES
        /// <summary> 
        /// 加密
        /// </summary> 
        public class AES
        {
            RijndaelManaged rijndaelProvider;
            ICryptoTransform rijndaelEncrypt;
            ICryptoTransform rijndaelDecrypt;
            /// <summary>
            /// 默认构造函数
            /// </summary>
            public AES()
                : this("DEFAULT CRYPTKEY")
            {

            }
            /// <summary>
            /// 
            /// </summary>
            /// <param name="_encryptKey"></param>
            public AES(string _encryptKey)
            {
                _encryptKey = _encryptKey.CutString(32);
                _encryptKey = _encryptKey.PadRight(32, ' ');
                rijndaelProvider = new RijndaelManaged();
                rijndaelProvider.Key = Encoding.UTF8.GetBytes(_encryptKey);
                rijndaelProvider.IV = Keys;
                rijndaelEncrypt = rijndaelProvider.CreateEncryptor();
                rijndaelDecrypt = rijndaelProvider.CreateDecryptor();
            }

            //默认密钥向量
            private static byte[] Keys = { 0x41, 0x72, 0x65, 0x79, 0x6F, 0x75, 0x6D, 0x79, 0x53, 0x6E, 0x6F, 0x77, 0x6D, 0x61, 0x6E, 0x3F };
            /// <summary>
            /// 加密
            /// </summary>
            /// <param name="encryptString"></param>
            /// <param name="encryptKey"></param>
            /// <returns></returns>
            public string Encrypt(string encryptString)
            {
                byte[] inputData = Encoding.UTF8.GetBytes(encryptString);
                byte[] encryptedData = rijndaelEncrypt.TransformFinalBlock(inputData, 0, inputData.Length);
                return Convert.ToBase64String(encryptedData);
            }
            /// <summary>
            /// 解密
            /// </summary>
            /// <param name="decryptString"></param>
            /// <param name="decryptKey"></param>
            /// <returns></returns>
            public string Decrypt(string decryptString)
            {
                try
                {
                    byte[] inputData = Convert.FromBase64String(decryptString);
                    byte[] decryptedData = rijndaelDecrypt.TransformFinalBlock(inputData, 0, inputData.Length);
                    return Encoding.UTF8.GetString(decryptedData);
                }
                catch (Exception ex)
                {
                    LogHelper.Fatal("解密错误", ex);
                    return string.Empty;
                }
            }

        }
        #endregion

        #region des
        ///// <summary> 
        ///// 加密
        ///// </summary> 
        //public class DES
        //{
        //    //默认密钥向量
        //    private static byte[] Keys = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };

        //    /// <summary>
        //    /// DES加密字符串
        //    /// </summary>
        //    /// <param name="encryptString">待加密的字符串</param>
        //    /// <param name="encryptKey">加密密钥,要求为8位</param>
        //    /// <returns>加密成功返回加密后的字符串,失败返回源串</returns>
        //    public static string Encode(string encryptString, string encryptKey)
        //    {
        //        encryptKey = encryptKey.CutString(8);
        //        encryptKey = encryptKey.PadRight(8, ' ');
        //        byte[] rgbKey = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 8));
        //        byte[] rgbIV = Keys;
        //        byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
        //        DESCryptoServiceProvider dCSP = new DESCryptoServiceProvider();
        //        MemoryStream mStream = new MemoryStream();
        //        CryptoStream cStream = new CryptoStream(mStream, dCSP.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
        //        cStream.Write(inputByteArray, 0, inputByteArray.Length);
        //        cStream.FlushFinalBlock();
        //        return Convert.ToBase64String(mStream.ToArray());

        //    }

        //    /// <summary>
        //    /// DES解密字符串
        //    /// </summary>
        //    /// <param name="decryptString">待解密的字符串</param>
        //    /// <param name="decryptKey">解密密钥,要求为8位,和加密密钥相同</param>
        //    /// <returns>解密成功返回解密后的字符串,失败返源串</returns>
        //    public static string Decode(string decryptString, string decryptKey)
        //    {
        //        try
        //        {
        //            decryptKey = decryptKey.CutString(8);
        //            decryptKey = decryptKey.PadRight(8, ' ');
        //            byte[] rgbKey = Encoding.UTF8.GetBytes(decryptKey);
        //            byte[] rgbIV = Keys;
        //            byte[] inputByteArray = Convert.FromBase64String(decryptString);
        //            DESCryptoServiceProvider DCSP = new DESCryptoServiceProvider();

        //            MemoryStream mStream = new MemoryStream();
        //            CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
        //            cStream.Write(inputByteArray, 0, inputByteArray.Length);
        //            cStream.FlushFinalBlock();
        //            return Encoding.UTF8.GetString(mStream.ToArray());
        //        }
        //        catch
        //        {
        //            return "";
        //        }
        //    }


















        //    //public static string DecryptString(string strText, string key)
        //    //{
        //    //    try
        //    //    {
        //    //        byte[] buffer = new MD5CryptoServiceProvider().ComputeHash(Encoding.ASCII.GetBytes(key));
        //    //        TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider();
        //    //        provider.Key = buffer;
        //    //        provider.Mode = CipherMode.ECB;
        //    //        byte[] inputBuffer = Convert.FromBase64String(strText);
        //    //        return Encoding.ASCII.GetString(provider.CreateDecryptor().TransformFinalBlock(inputBuffer, 0, inputBuffer.Length));
        //    //    }
        //    //    catch (Exception ex)
        //    //    {
        //    //        throw new ApplicationException("解密字符串错误：" + key, ex);
        //    //    }
        //    //}

        //    //public static string DecryptUTF8String(string strText, string key)
        //    //{
        //    //    try
        //    //    {
        //    //        byte[] buffer = new MD5CryptoServiceProvider().ComputeHash(Encoding.UTF8.GetBytes(key));
        //    //        TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider();
        //    //        provider.Key = buffer;
        //    //        provider.Mode = CipherMode.ECB;
        //    //        byte[] inputBuffer = Convert.FromBase64String(strText);
        //    //        return Encoding.UTF8.GetString(provider.CreateDecryptor().TransformFinalBlock(inputBuffer, 0, inputBuffer.Length));
        //    //    }
        //    //    catch (Exception ex)
        //    //    {
        //    //        throw new ApplicationException("解密字符串错误：" + key, ex);
        //    //    }
        //    //}

        //    //public static string EncryptString(string strText, string key)
        //    //{
        //    //    try
        //    //    {
        //    //        byte[] buffer = new MD5CryptoServiceProvider().ComputeHash(Encoding.ASCII.GetBytes(key));
        //    //        TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider();
        //    //        provider.Key = buffer;
        //    //        provider.Mode = CipherMode.ECB;
        //    //        byte[] bytes = Encoding.ASCII.GetBytes(strText);
        //    //        string str = Convert.ToBase64String(provider.CreateEncryptor().TransformFinalBlock(bytes, 0, bytes.Length));
        //    //        provider = null;
        //    //        return str;
        //    //    }
        //    //    catch (Exception ex)
        //    //    {
        //    //        throw new ApplicationException("加密字符串错误：" + key, ex);
        //    //    }
        //    //}

        //    //public static string EncryptUTF8String(string strText, string key)
        //    //{
        //    //    try
        //    //    {
        //    //        byte[] buffer = new MD5CryptoServiceProvider().ComputeHash(Encoding.UTF8.GetBytes(key));
        //    //        TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider();
        //    //        provider.Key = buffer;
        //    //        provider.Mode = CipherMode.ECB;
        //    //        byte[] bytes = Encoding.UTF8.GetBytes(strText);
        //    //        string str = Convert.ToBase64String(provider.CreateEncryptor().TransformFinalBlock(bytes, 0, bytes.Length));
        //    //        provider = null;
        //    //        return str;
        //    //    }
        //    //    catch (Exception ex)
        //    //    {
        //    //        throw new ApplicationException("加密字符串错误：" + key, ex);
        //    //    }
        //    //}
        //}
        #endregion
    }
}
